Fzzy Config/me.fzzyhmstrs.fzzy_config.validation.misc/ValidatedCondition

ValidatedCondition

open class ValidatedCondition<T> : ValidatedMapped<T, T>

a validated value with a fallback that is supplied if provided conditions aren't passed

Author

fzzyhmstrs since 0.5.4

Parameters

the type being wrapped

delegate

ValidatedField the field being wrapped with conditions

fallback

Supplier<T> supplies fallback values if the condition fails

Throws

IllegalStateException

if the passed fallback is the same as the delegate

Samples

import me.fzzyhmstrs.fzzy_config.util.AllowableIdentifiers
import me.fzzyhmstrs.fzzy_config.util.EnumTranslatable
import me.fzzyhmstrs.fzzy_config.util.FcText.lit
import me.fzzyhmstrs.fzzy_config.util.ValidationResult
import me.fzzyhmstrs.fzzy_config.validation.collection.ValidatedList
import me.fzzyhmstrs.fzzy_config.validation.minecraft.ValidatedIdentifier
import me.fzzyhmstrs.fzzy_config.validation.minecraft.ValidatedRegistryType
import me.fzzyhmstrs.fzzy_config.validation.minecraft.ValidatedTagKey
import me.fzzyhmstrs.fzzy_config.validation.misc.*
import me.fzzyhmstrs.fzzy_config.validation.misc.ValidatedColor.Companion.validatedColor
import me.fzzyhmstrs.fzzy_config.validation.number.ValidatedInt
import net.minecraft.item.Items
import net.minecraft.item.SwordItem
import net.minecraft.registry.Registries
import net.minecraft.registry.tag.ItemTags
import net.minecraft.util.Identifier
import java.awt.Color
import java.util.function.Function

fun main() { 
   //sampleStart 
   //any validation can be wrapped in conditions. All the conditions need to pass, otherwise a fallback will be returned instead of the stored value
// conditions should supply live values. Validated fields are a convenient mechanism to do that. A plain boolean won't update in-GUI until changes are applied.
val validatedBooleanGate = ValidatedBoolean()

//create a conditional validation with toCondition
val validatedConditionInt = ValidatedInt(5, 100, 0).toCondition(validatedBooleanGate, "Gate must be true".lit()) { 0 } 
   //sampleEnd
}

Types

Companion

object Companion

Condition

@FunctionalInterface

fun interface Condition : Supplier<Boolean>

A condition supplier with an attached message. The message should explain what is needed to pass the condition successfully

Properties

translatableEntryKey

open override var translatableEntryKey: String

Functions

open override fun accept(input: T)

updates the mapped value. NOTE: this method will push updates to an UpdateManager, if any. For in-game updating consider validateAndSet

addListener

open override fun ~~addListener~~(listener: Consumer<ValidatedField<T>>)

Attaches a listener to this field. This listener will be called any time the field is written to ("set"). accept, validateAndSet, setAndUpdate and so on will all call the listener.

andThen

open fun andThen(p0: Consumer<in T>): Consumer<T>

codec

fun codec(): Codec<T>

Provides a Codec representing the value type of this validation, backed by the validators within as applicable

copyStoredValue

open fun copyStoredValue(): T

Copies the stored value and returns it.

copyValue

open override fun copyValue(input: T): T

Copies the provided input as deeply as possible. For immutables like numbers and booleans, this will simply return the input

description

open fun description(fallback: String? = null): MutableText

The translated Text description from the descriptionKey. Falls back to an empty string so no tooltip is rendered.

descriptionKey

open override fun descriptionKey(): String

translation key of this Translatable's description. the "description" in-game, the descriptions Enchantment Descriptions adds to enchantment tooltips are a good example.

deserialize

open override fun deserialize(toml: TomlElement, fieldName: String): ValidationResult<T>

deserializes the fields stored value from TomlElement. This should not set the fields stored value, or interact with the field at all except to get the stored value for error reporting. deserializeEntry handles that.

deserializedChanged

open fun deserializedChanged(old: Any?, new: Any?): Boolean

Specialized equals method for determining if a newly deserialized value is effectively equal to its old counterpart.

flags

open override fun flags(): Byte

get

open override fun get(): T

provide the stored value, gated behind the results of any provided conditions. If any condition fails, this will return false no matter the underlying value

getDefault

fun getDefault(): T

Provides this validations default value

getUnconditional

fun getUnconditional(): T

Retrieves the wrapped value without performing condition checks

hasDescription

open fun hasDescription(): Boolean

Whether this Translatable has a valid description

hasPrefix

open fun hasPrefix(): Boolean

Whether this Translatable has a valid prefix

hasTranslation

open fun hasTranslation(): Boolean

Whether this Translatable has a valid translation

instanceEntry

open override fun instanceEntry(): ValidatedField<T>

creates a deep copy of this ValidatedCondition

isValidEntry

open override fun isValidEntry(input: Any?): Boolean

Tests an arbitrary input to determine if it is a valid input to this Entry. Inputs are not (necessarily) Entry, the term is used here in the general sense

listenToEntry

open override fun listenToEntry(listener: Consumer<Entry<T, *>>)

Attaches a listener to this field. This listener will be called any time the field is written to ("set"). accept, validateAndSet, setAndUpdate and so on will all call the listener.

map

fun <N> map(to: Function<T, out N>, from: Function<in N, T>): ValidatedField<N>

Maps this validation to a new convertible type. The default value will be applied from this delegates current storedValue

fun <N> map(defaultValue: N, to: Function<T, out N>, from: Function<in N, T>): ValidatedField<N>

fun <N> map(to: Function<T, out N>, from: Function<in N, T>, defaultValue: T): ValidatedField<N>

Maps this validation to a new convertible type.

pairWith

fun <B> pairWith(other: Entry<B, *>): ValidatedPair<T, B>

Pairs this validation with another validation into one ValidatedPair

prefix

open fun prefix(fallback: String? = null): MutableText

The translated Text description from the descriptionKey. Falls back to an empty string so no tooltip is rendered.

prefixKey

open override fun prefixKey(): String

translation key of this Translatable's inline prefix text. Unlike descriptions, which are usually displayed in-tooltips, prefixes are displayed inline in the config screen itself

prepare

open fun prepare(scope: String, groups: LinkedList<String>, annotations: List<Annotation>, globalAnnotations: List<Annotation>)

Called in the prepare stage of screen building to perform any necessary pre-entry-creation tasks.

toList

fun toList(vararg elements: T): ValidatedList<T>

Wraps the provided values into a ValidatedList with this field as validation

fun toList(collection: Collection<T>): ValidatedList<T>

Wraps the provided collection into a ValidatedList with this field as validation

toSet

fun toSet(vararg elements: T): ValidatedSet<T>

Wraps the provided values into a ValidatedSet with this field as validation

fun toSet(collection: Collection<T>): ValidatedSet<T>

Wraps the provided collection into a ValidatedSet with this field as validation

translationKey

open override fun translationKey(): String

translation key of this Translatable. the "name" in-game

trySerialize

fun trySerialize(input: Any?, errorBuilder: MutableList<String>, flags: Byte): TomlElement?

trySet

open override fun trySet(input: Any?)

Attempts to set an arbitrary input into this Entry. Should fail soft if the input is incompatible

update

open fun update(updateMessage: Text)

validateAndSet

open fun validateAndSet(input: T): ValidationResult<T>

A setter method for the storedValue that first validates the value being set and then stores the post-validation result.

validateAndSetFlagged

open fun validateAndSetFlagged(input: T, vararg flag: EntryFlag.Flag): ValidationResult<T>

A setter method for the storedValue that first validates the value being set and then stores the post-validation result.

widgetAndTooltipEntry

open fun widgetAndTooltipEntry(choicePredicate: ChoiceValidator<T> = ChoiceValidator.any()): ClickableWidget

Builds a new ClickableWidget and applies a tooltip to it. This shouldn't need to be overridden in most cases

withCondition

open fun withCondition(condition: ValidatedField<Boolean>): ValidatedCondition<T>

Adds a conditional check to this ValidatedCondition using the provided validated field as a supplier. Apply conditional checks on top of the stored value by calling get. Get the base value with getUnconditional.

open fun withCondition(condition: ValidatedCondition.Condition): ValidatedCondition<T>

open fun withCondition(condition: Supplier<Boolean>, failMessage: Text): ValidatedCondition<T>

Adds a conditional check to this ValidatedCondition. Apply conditional checks on top of the stored value by calling get. Get the base value with getUnconditional.

open fun withCondition(scope: String, failMessage: Text): ValidatedCondition<T>

Adds a conditional check to this ValidatedCondition using the provided scope against a boolean provider. Apply conditional checks on top of the stored value by calling get. Get the base value with getUnconditional. The provided scope must point to a valid boolean config scope otherwise the condition will never pass.

withFailTitle

@JvmOverloads

fun withFailTitle(singleFailText: Text, pluralFailText: Text? = null): ValidatedCondition<T>

Defines a custom condition fail-state title to appear in the de-activated widget. By default, (in english) these are "Condition not met" and "Conditions not met". A more specific message may be appropriate for user guidance, such as "|setting| disabled"